describe(ꞌIP library for node.jsꞌ) - Code Metrics - LukasMeine/vigilance - Measure and Improve Code Quality continuously with Scrutinizer

describe(ꞌIP library for node.jsꞌ) A
last analyzed 2018-08-02 16:14 UTC

↳ Parent: describe(ꞌIP library for node.jsꞌ)

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	8
nc	1
nop	0
dl	0
loc	10
rs	10
c	0
b	0
f	0

'use strict';

var ip = require('..');
var assert = require('assert');
var net = require('net');
var os = require('os');

describe('IP library for node.js', function() {
  describe('toBuffer()/toString() methods', function() {
    it('should convert to buffer IPv4 address', function() {
      var buf = ip.toBuffer('127.0.0.1');
      assert.equal(buf.toString('hex'), '7f000001');
      assert.equal(ip.toString(buf), '127.0.0.1');
    });

    it('should convert to buffer IPv4 address in-place', function() {
      var buf = new Buffer(128);

      var offset = 64;
      ip.toBuffer('127.0.0.1', buf, offset);
      assert.equal(buf.toString('hex', offset, offset + 4), '7f000001');
      assert.equal(ip.toString(buf, offset, 4), '127.0.0.1');
    });

    it('should convert to buffer IPv6 address', function() {
      var buf = ip.toBuffer('::1');
      assert(/(00){15,15}01/.test(buf.toString('hex')));
      assert.equal(ip.toString(buf), '::1');
      assert.equal(ip.toString(ip.toBuffer('1::')), '1::');
      assert.equal(ip.toString(ip.toBuffer('abcd::dcba')), 'abcd::dcba');
    });

    it('should convert to buffer IPv6 address in-place', function() {
      var buf = new Buffer(128);

      var offset = 64;
      ip.toBuffer('::1', buf, offset);
      assert(/(00){15,15}01/.test(buf.toString('hex', offset, offset + 16)));
      assert.equal(ip.toString(buf, offset, 16), '::1');
      assert.equal(ip.toString(ip.toBuffer('1::', buf, offset),
                               offset, 16), '1::');
      assert.equal(ip.toString(ip.toBuffer('abcd::dcba', buf, offset),
                               offset, 16), 'abcd::dcba');
    });

    it('should convert to buffer IPv6 mapped IPv4 address', function() {
      var buf = ip.toBuffer('::ffff:127.0.0.1');
      assert.equal(buf.toString('hex'), '00000000000000000000ffff7f000001');
      assert.equal(ip.toString(buf), '::ffff:7f00:1');

      buf = ip.toBuffer('ffff::127.0.0.1');
      assert.equal(buf.toString('hex'), 'ffff000000000000000000007f000001');
      assert.equal(ip.toString(buf), 'ffff::7f00:1');

      buf = ip.toBuffer('0:0:0:0:0:ffff:127.0.0.1');
      assert.equal(buf.toString('hex'), '00000000000000000000ffff7f000001');
      assert.equal(ip.toString(buf), '::ffff:7f00:1');
    });
  });

  describe('fromPrefixLen() method', function() {
    it('should create IPv4 mask', function() {
      assert.equal(ip.fromPrefixLen(24), '255.255.255.0');
    });
    it('should create IPv6 mask', function() {
      assert.equal(ip.fromPrefixLen(64), 'ffff:ffff:ffff:ffff::');
    });
    it('should create IPv6 mask explicitly', function() {
      assert.equal(ip.fromPrefixLen(24, 'IPV6'), 'ffff:ff00::');
    });
  });

  describe('not() method', function() {
    it('should reverse bits in address', function() {
      assert.equal(ip.not('255.255.255.0'), '0.0.0.255');
    });
  });

  describe('or() method', function() {
    it('should or bits in ipv4 addresses', function() {
      assert.equal(ip.or('0.0.0.255', '192.168.1.10'), '192.168.1.255');
    });
    it('should or bits in ipv6 addresses', function() {
      assert.equal(ip.or('::ff', '::abcd:dcba:abcd:dcba'),
                   '::abcd:dcba:abcd:dcff');
    });
    it('should or bits in mixed addresses', function() {
      assert.equal(ip.or('0.0.0.255', '::abcd:dcba:abcd:dcba'),
                   '::abcd:dcba:abcd:dcff');
    });
  });

  describe('mask() method', function() {
    it('should mask bits in address', function() {
      assert.equal(ip.mask('192.168.1.134', '255.255.255.0'), '192.168.1.0');
      assert.equal(ip.mask('192.168.1.134', '::ffff:ff00'), '::ffff:c0a8:100');
    });

    it('should not leak data', function() {
      for (var i = 0; i < 10; i++)
        assert.equal(ip.mask('::1', '0.0.0.0'), '::');
if (a > 0)
    b = 42;
    });
  });

  describe('subnet() method', function() {
    // Test cases calculated with http://www.subnet-calculator.com/
    var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.192');

    it('should compute ipv4 network address', function() {
      assert.equal(ipv4Subnet.networkAddress, '192.168.1.128');
    });

    it('should compute ipv4 network\'s first address', function() {
      assert.equal(ipv4Subnet.firstAddress, '192.168.1.129');
    });

    it('should compute ipv4 network\'s last address', function() {
      assert.equal(ipv4Subnet.lastAddress, '192.168.1.190');
    });

    it('should compute ipv4 broadcast address', function() {
      assert.equal(ipv4Subnet.broadcastAddress, '192.168.1.191');
    });

    it('should compute ipv4 subnet number of addresses', function() {
      assert.equal(ipv4Subnet.length, 64);
    });

    it('should compute ipv4 subnet number of addressable hosts', function() {
      assert.equal(ipv4Subnet.numHosts, 62);
    });

    it('should compute ipv4 subnet mask', function() {
      assert.equal(ipv4Subnet.subnetMask, '255.255.255.192');
    });

    it('should compute ipv4 subnet mask\'s length', function() {
      assert.equal(ipv4Subnet.subnetMaskLength, 26);
    });

    it('should know whether a subnet contains an address', function() {
      assert.equal(ipv4Subnet.contains('192.168.1.180'), true);
    });

    it('should know whether a subnet does not contain an address', function() {
      assert.equal(ipv4Subnet.contains('192.168.1.195'), false);
    });
  });

  describe('subnet() method with mask length 32', function() {
    // Test cases calculated with http://www.subnet-calculator.com/
    var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.255');
    it('should compute ipv4 network\'s first address', function() {
      assert.equal(ipv4Subnet.firstAddress, '192.168.1.134');
    });

    it('should compute ipv4 network\'s last address', function() {
      assert.equal(ipv4Subnet.lastAddress, '192.168.1.134');
    });

    it('should compute ipv4 subnet number of addressable hosts', function() {
      assert.equal(ipv4Subnet.numHosts, 1);
    });
  });

  describe('subnet() method with mask length 31', function() {
    // Test cases calculated with http://www.subnet-calculator.com/
    var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.254');
    it('should compute ipv4 network\'s first address', function() {
      assert.equal(ipv4Subnet.firstAddress, '192.168.1.134');
    });

    it('should compute ipv4 network\'s last address', function() {
      assert.equal(ipv4Subnet.lastAddress, '192.168.1.135');
    });

    it('should compute ipv4 subnet number of addressable hosts', function() {
      assert.equal(ipv4Subnet.numHosts, 2);
    });
  });

  describe('cidrSubnet() method', function() {
    // Test cases calculated with http://www.subnet-calculator.com/
    var ipv4Subnet = ip.cidrSubnet('192.168.1.134/26');

    it('should compute an ipv4 network address', function() {
      assert.equal(ipv4Subnet.networkAddress, '192.168.1.128');
    });

    it('should compute an ipv4 network\'s first address', function() {
      assert.equal(ipv4Subnet.firstAddress, '192.168.1.129');
    });

    it('should compute an ipv4 network\'s last address', function() {
      assert.equal(ipv4Subnet.lastAddress, '192.168.1.190');
    });

    it('should compute an ipv4 broadcast address', function() {
      assert.equal(ipv4Subnet.broadcastAddress, '192.168.1.191');
    });

    it('should compute an ipv4 subnet number of addresses', function() {
      assert.equal(ipv4Subnet.length, 64);
    });

    it('should compute an ipv4 subnet number of addressable hosts', function() {
      assert.equal(ipv4Subnet.numHosts, 62);
    });

    it('should compute an ipv4 subnet mask', function() {
      assert.equal(ipv4Subnet.subnetMask, '255.255.255.192');
    });

    it('should compute an ipv4 subnet mask\'s length', function() {
      assert.equal(ipv4Subnet.subnetMaskLength, 26);
    });

    it('should know whether a subnet contains an address', function() {
      assert.equal(ipv4Subnet.contains('192.168.1.180'), true);
    });

    it('should know whether a subnet contains an address', function() {
      assert.equal(ipv4Subnet.contains('192.168.1.195'), false);
    });

  });

  describe('cidr() method', function() {
    it('should mask address in CIDR notation', function() {
      assert.equal(ip.cidr('192.168.1.134/26'), '192.168.1.128');
      assert.equal(ip.cidr('2607:f0d0:1002:51::4/56'), '2607:f0d0:1002::');
    });
  });

  describe('isEqual() method', function() {
    it('should check if addresses are equal', function() {
      assert(ip.isEqual('127.0.0.1', '::7f00:1'));
      assert(!ip.isEqual('127.0.0.1', '::7f00:2'));
      assert(ip.isEqual('127.0.0.1', '::ffff:7f00:1'));
      assert(!ip.isEqual('127.0.0.1', '::ffaf:7f00:1'));
      assert(ip.isEqual('::ffff:127.0.0.1', '::ffff:127.0.0.1'));
      assert(ip.isEqual('::ffff:127.0.0.1', '127.0.0.1'));
    });
  });


  describe('isPrivate() method', function() {
    it('should check if an address is localhost', function() {
      assert.equal(ip.isPrivate('127.0.0.1'), true);
    });

    it('should check if an address is from a 192.168.x.x network', function() {
      assert.equal(ip.isPrivate('192.168.0.123'), true);
      assert.equal(ip.isPrivate('192.168.122.123'), true);
      assert.equal(ip.isPrivate('192.162.1.2'), false);
    });

    it('should check if an address is from a 172.16.x.x network', function() {
      assert.equal(ip.isPrivate('172.16.0.5'), true);
      assert.equal(ip.isPrivate('172.16.123.254'), true);
      assert.equal(ip.isPrivate('171.16.0.5'), false);
      assert.equal(ip.isPrivate('172.25.232.15'), true);
      assert.equal(ip.isPrivate('172.15.0.5'), false);
      assert.equal(ip.isPrivate('172.32.0.5'), false);
    });

    it('should check if an address is from a 169.254.x.x network', function() {
      assert.equal(ip.isPrivate('169.254.2.3'), true);
      assert.equal(ip.isPrivate('169.254.221.9'), true);
      assert.equal(ip.isPrivate('168.254.2.3'), false);
    });

    it('should check if an address is from a 10.x.x.x network', function() {
      assert.equal(ip.isPrivate('10.0.2.3'), true);
      assert.equal(ip.isPrivate('10.1.23.45'), true);
      assert.equal(ip.isPrivate('12.1.2.3'), false);
    });

    it('should check if an address is from a private IPv6 network', function() {
      assert.equal(ip.isPrivate('fd12:3456:789a:1::1'), true);
      assert.equal(ip.isPrivate('fe80::f2de:f1ff:fe3f:307e'), true);
      assert.equal(ip.isPrivate('::ffff:10.100.1.42'), true);
      assert.equal(ip.isPrivate('::FFFF:172.16.200.1'), true);
      assert.equal(ip.isPrivate('::ffff:192.168.0.1'), true);
    });

    it('should check if an address is from the internet', function() {
      assert.equal(ip.isPrivate('165.225.132.33'), false); // joyent.com
    });

    it('should check if an address is a loopback IPv6 address', function() {
      assert.equal(ip.isPrivate('::'), true);
      assert.equal(ip.isPrivate('::1'), true);
      assert.equal(ip.isPrivate('fe80::1'), true);
    });
  });

  describe('loopback() method', function() {
    describe('undefined', function() {
      it('should respond with 127.0.0.1', function() {
        assert.equal(ip.loopback(), '127.0.0.1')
      });
    });

    describe('ipv4', function() {
      it('should respond with 127.0.0.1', function() {
        assert.equal(ip.loopback('ipv4'), '127.0.0.1')
      });
    });

    describe('ipv6', function() {
      it('should respond with fe80::1', function() {
        assert.equal(ip.loopback('ipv6'), 'fe80::1')
      });
    });
  });

  describe('isLoopback() method', function() {
    describe('127.0.0.1', function() {
      it('should respond with true', function() {
        assert.ok(ip.isLoopback('127.0.0.1'))
      });
    });

    describe('127.8.8.8', function () {
      it('should respond with true', function () {
        assert.ok(ip.isLoopback('127.8.8.8'))
      });
    });

    describe('8.8.8.8', function () {
      it('should respond with false', function () {
        assert.equal(ip.isLoopback('8.8.8.8'), false);
      });
    });

    describe('fe80::1', function() {
      it('should respond with true', function() {
        assert.ok(ip.isLoopback('fe80::1'))
      });
    });

    describe('::1', function() {
      it('should respond with true', function() {
        assert.ok(ip.isLoopback('::1'))
      });
    });

    describe('::', function() {
      it('should respond with true', function() {
        assert.ok(ip.isLoopback('::'))
      });
    });
  });

  describe('address() method', function() {
    describe('undefined', function() {
      it('should respond with a private ip', function() {
        assert.ok(ip.isPrivate(ip.address()));
      });
    });

    describe('private', function() {
      [ undefined, 'ipv4', 'ipv6' ].forEach(function(family) {
        describe(family, function() {
          it('should respond with a private ip', function() {
            assert.ok(ip.isPrivate(ip.address('private', family)));
          });
        });
      });
    });

    var interfaces = os.networkInterfaces();

    Object.keys(interfaces).forEach(function(nic) {
      describe(nic, function() {
        [ undefined, 'ipv4' ].forEach(function(family) {
          describe(family, function() {
            it('should respond with an ipv4 address', function() {
              var addr = ip.address(nic, family);
              assert.ok(!addr || net.isIPv4(addr));
            });
          });
        });

        describe('ipv6', function() {
          it('should respond with an ipv6 address', function() {
            var addr = ip.address(nic, 'ipv6');
            assert.ok(!addr || net.isIPv6(addr));
          });
        })
      });
    });
  });

  describe('toLong() method', function() {
    it('should respond with a int', function() {
      assert.equal(ip.toLong('127.0.0.1'), 2130706433);
      assert.equal(ip.toLong('255.255.255.255'), 4294967295);
    });
  });

  describe('fromLong() method', function() {
    it('should repond with ipv4 address', function() {
      assert.equal(ip.fromLong(2130706433), '127.0.0.1');
      assert.equal(ip.fromLong(4294967295), '255.255.255.255');
    });
  })
});


1			'use strict';
2
3			var ip = require('..');
4			var assert = require('assert');
5			var net = require('net');
6			var os = require('os');
7
8			describe('IP library for node.js', function() {
9			describe('toBuffer()/toString() methods', function() {
10			it('should convert to buffer IPv4 address', function() {
11			var buf = ip.toBuffer('127.0.0.1');
12			assert.equal(buf.toString('hex'), '7f000001');
13			assert.equal(ip.toString(buf), '127.0.0.1');
14			});
15
16			it('should convert to buffer IPv4 address in-place', function() {
17			var buf = new Buffer(128);
			0 ignored issues – show Bug introduced 2018-05-14 04:10 UTC by Report Bug Copy Issue Report The variable `Buffer` seems to be never declared. If this is a global, consider adding a `/** global: Buffer */` comment. This checks looks for references to variables that have not been declared. This is most likey a typographical error or a variable has been renamed. To learn more about declaring variables in Javascript, see the MDN. Loading history...
18			var offset = 64;
19			ip.toBuffer('127.0.0.1', buf, offset);
20			assert.equal(buf.toString('hex', offset, offset + 4), '7f000001');
21			assert.equal(ip.toString(buf, offset, 4), '127.0.0.1');
22			});
23
24			it('should convert to buffer IPv6 address', function() {
25			var buf = ip.toBuffer('::1');
26			assert(/(00){15,15}01/.test(buf.toString('hex')));
27			assert.equal(ip.toString(buf), '::1');
28			assert.equal(ip.toString(ip.toBuffer('1::')), '1::');
29			assert.equal(ip.toString(ip.toBuffer('abcd::dcba')), 'abcd::dcba');
30			});
31
32			it('should convert to buffer IPv6 address in-place', function() {
33			var buf = new Buffer(128);
			0 ignored issues – show Bug introduced 2018-05-14 04:10 UTC by Report Bug Copy Issue Report The variable `Buffer` seems to be never declared. If this is a global, consider adding a `/** global: Buffer */` comment. This checks looks for references to variables that have not been declared. This is most likey a typographical error or a variable has been renamed. To learn more about declaring variables in Javascript, see the MDN. Loading history...
34			var offset = 64;
35			ip.toBuffer('::1', buf, offset);
36			assert(/(00){15,15}01/.test(buf.toString('hex', offset, offset + 16)));
37			assert.equal(ip.toString(buf, offset, 16), '::1');
38			assert.equal(ip.toString(ip.toBuffer('1::', buf, offset),
39			offset, 16), '1::');
40			assert.equal(ip.toString(ip.toBuffer('abcd::dcba', buf, offset),
41			offset, 16), 'abcd::dcba');
42			});
43
44			it('should convert to buffer IPv6 mapped IPv4 address', function() {
45			var buf = ip.toBuffer('::ffff:127.0.0.1');
46			assert.equal(buf.toString('hex'), '00000000000000000000ffff7f000001');
47			assert.equal(ip.toString(buf), '::ffff:7f00:1');
48
49			buf = ip.toBuffer('ffff::127.0.0.1');
50			assert.equal(buf.toString('hex'), 'ffff000000000000000000007f000001');
51			assert.equal(ip.toString(buf), 'ffff::7f00:1');
52
53			buf = ip.toBuffer('0:0:0:0:0:ffff:127.0.0.1');
54			assert.equal(buf.toString('hex'), '00000000000000000000ffff7f000001');
55			assert.equal(ip.toString(buf), '::ffff:7f00:1');
56			});
57			});
58
59			describe('fromPrefixLen() method', function() {
60			it('should create IPv4 mask', function() {
61			assert.equal(ip.fromPrefixLen(24), '255.255.255.0');
62			});
63			it('should create IPv6 mask', function() {
64			assert.equal(ip.fromPrefixLen(64), 'ffff:ffff:ffff:ffff::');
65			});
66			it('should create IPv6 mask explicitly', function() {
67			assert.equal(ip.fromPrefixLen(24, 'IPV6'), 'ffff:ff00::');
68			});
69			});
70
71			describe('not() method', function() {
72			it('should reverse bits in address', function() {
73			assert.equal(ip.not('255.255.255.0'), '0.0.0.255');
74			});
75			});
76
77			describe('or() method', function() {
78			it('should or bits in ipv4 addresses', function() {
79			assert.equal(ip.or('0.0.0.255', '192.168.1.10'), '192.168.1.255');
80			});
81			it('should or bits in ipv6 addresses', function() {
82			assert.equal(ip.or('::ff', '::abcd:dcba:abcd:dcba'),
83			'::abcd:dcba:abcd:dcff');
84			});
85			it('should or bits in mixed addresses', function() {
86			assert.equal(ip.or('0.0.0.255', '::abcd:dcba:abcd:dcba'),
87			'::abcd:dcba:abcd:dcff');
88			});
89			});
90
91			describe('mask() method', function() {
92			it('should mask bits in address', function() {
93			assert.equal(ip.mask('192.168.1.134', '255.255.255.0'), '192.168.1.0');
94			assert.equal(ip.mask('192.168.1.134', '::ffff:ff00'), '::ffff:c0a8:100');
95			});
96
97			it('should not leak data', function() {
98			for (var i = 0; i < 10; i++)
99			assert.equal(ip.mask('::1', '0.0.0.0'), '::');
			0 ignored issues – show Coding Style Best Practice introduced 2018-05-14 04:10 UTC by Report Bug Copy Issue Report Curly braces around statements make for more readable code and help prevent bugs when you add further statements. Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later. Consider: if (a > 0) b = 42; If you or someone else later decides to put another statement in, only the first statement will be executed. if (a > 0) console.log("a > 0"); b = 42; In this case the statement `b = 42` will always be executed, while the logging statement will be executed conditionally. if (a > 0) { console.log("a > 0"); b = 42; } ensures that the proper code will be executed conditionally no matter how many statements are added or removed. Loading history...
100			});
101			});
102
103			describe('subnet() method', function() {
104			// Test cases calculated with http://www.subnet-calculator.com/
105			var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.192');
106
107			it('should compute ipv4 network address', function() {
108			assert.equal(ipv4Subnet.networkAddress, '192.168.1.128');
109			});
110
111			it('should compute ipv4 network\'s first address', function() {
112			assert.equal(ipv4Subnet.firstAddress, '192.168.1.129');
113			});
114
115			it('should compute ipv4 network\'s last address', function() {
116			assert.equal(ipv4Subnet.lastAddress, '192.168.1.190');
117			});
118
119			it('should compute ipv4 broadcast address', function() {
120			assert.equal(ipv4Subnet.broadcastAddress, '192.168.1.191');
121			});
122
123			it('should compute ipv4 subnet number of addresses', function() {
124			assert.equal(ipv4Subnet.length, 64);
125			});
126
127			it('should compute ipv4 subnet number of addressable hosts', function() {
128			assert.equal(ipv4Subnet.numHosts, 62);
129			});
130
131			it('should compute ipv4 subnet mask', function() {
132			assert.equal(ipv4Subnet.subnetMask, '255.255.255.192');
133			});
134
135			it('should compute ipv4 subnet mask\'s length', function() {
136			assert.equal(ipv4Subnet.subnetMaskLength, 26);
137			});
138
139			it('should know whether a subnet contains an address', function() {
140			assert.equal(ipv4Subnet.contains('192.168.1.180'), true);
141			});
142
143			it('should know whether a subnet does not contain an address', function() {
144			assert.equal(ipv4Subnet.contains('192.168.1.195'), false);
145			});
146			});
147
148			describe('subnet() method with mask length 32', function() {
149			// Test cases calculated with http://www.subnet-calculator.com/
150			var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.255');
151			it('should compute ipv4 network\'s first address', function() {
152			assert.equal(ipv4Subnet.firstAddress, '192.168.1.134');
153			});
154
155			it('should compute ipv4 network\'s last address', function() {
156			assert.equal(ipv4Subnet.lastAddress, '192.168.1.134');
157			});
158
159			it('should compute ipv4 subnet number of addressable hosts', function() {
160			assert.equal(ipv4Subnet.numHosts, 1);
161			});
162			});
163
164			describe('subnet() method with mask length 31', function() {
165			// Test cases calculated with http://www.subnet-calculator.com/
166			var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.254');
167			it('should compute ipv4 network\'s first address', function() {
168			assert.equal(ipv4Subnet.firstAddress, '192.168.1.134');
169			});
170
171			it('should compute ipv4 network\'s last address', function() {
172			assert.equal(ipv4Subnet.lastAddress, '192.168.1.135');
173			});
174
175			it('should compute ipv4 subnet number of addressable hosts', function() {
176			assert.equal(ipv4Subnet.numHosts, 2);
177			});
178			});
179
180			describe('cidrSubnet() method', function() {
181			// Test cases calculated with http://www.subnet-calculator.com/
182			var ipv4Subnet = ip.cidrSubnet('192.168.1.134/26');
183
184			it('should compute an ipv4 network address', function() {
185			assert.equal(ipv4Subnet.networkAddress, '192.168.1.128');
186			});
187
188			it('should compute an ipv4 network\'s first address', function() {
189			assert.equal(ipv4Subnet.firstAddress, '192.168.1.129');
190			});
191
192			it('should compute an ipv4 network\'s last address', function() {
193			assert.equal(ipv4Subnet.lastAddress, '192.168.1.190');
194			});
195
196			it('should compute an ipv4 broadcast address', function() {
197			assert.equal(ipv4Subnet.broadcastAddress, '192.168.1.191');
198			});
199
200			it('should compute an ipv4 subnet number of addresses', function() {
201			assert.equal(ipv4Subnet.length, 64);
202			});
203
204			it('should compute an ipv4 subnet number of addressable hosts', function() {
205			assert.equal(ipv4Subnet.numHosts, 62);
206			});
207
208			it('should compute an ipv4 subnet mask', function() {
209			assert.equal(ipv4Subnet.subnetMask, '255.255.255.192');
210			});
211
212			it('should compute an ipv4 subnet mask\'s length', function() {
213			assert.equal(ipv4Subnet.subnetMaskLength, 26);
214			});
215
216			it('should know whether a subnet contains an address', function() {
217			assert.equal(ipv4Subnet.contains('192.168.1.180'), true);
218			});
219
220			it('should know whether a subnet contains an address', function() {
221			assert.equal(ipv4Subnet.contains('192.168.1.195'), false);
222			});
223
224			});
225
226			describe('cidr() method', function() {
227			it('should mask address in CIDR notation', function() {
228			assert.equal(ip.cidr('192.168.1.134/26'), '192.168.1.128');
229			assert.equal(ip.cidr('2607:f0d0:1002:51::4/56'), '2607:f0d0:1002::');
230			});
231			});
232
233			describe('isEqual() method', function() {
234			it('should check if addresses are equal', function() {
235			assert(ip.isEqual('127.0.0.1', '::7f00:1'));
236			assert(!ip.isEqual('127.0.0.1', '::7f00:2'));
237			assert(ip.isEqual('127.0.0.1', '::ffff:7f00:1'));
238			assert(!ip.isEqual('127.0.0.1', '::ffaf:7f00:1'));
239			assert(ip.isEqual('::ffff:127.0.0.1', '::ffff:127.0.0.1'));
240			assert(ip.isEqual('::ffff:127.0.0.1', '127.0.0.1'));
241			});
242			});
243
244
245			describe('isPrivate() method', function() {
246			it('should check if an address is localhost', function() {
247			assert.equal(ip.isPrivate('127.0.0.1'), true);
248			});
249
250			it('should check if an address is from a 192.168.x.x network', function() {
251			assert.equal(ip.isPrivate('192.168.0.123'), true);
252			assert.equal(ip.isPrivate('192.168.122.123'), true);
253			assert.equal(ip.isPrivate('192.162.1.2'), false);
254			});
255
256			it('should check if an address is from a 172.16.x.x network', function() {
257			assert.equal(ip.isPrivate('172.16.0.5'), true);
258			assert.equal(ip.isPrivate('172.16.123.254'), true);
259			assert.equal(ip.isPrivate('171.16.0.5'), false);
260			assert.equal(ip.isPrivate('172.25.232.15'), true);
261			assert.equal(ip.isPrivate('172.15.0.5'), false);
262			assert.equal(ip.isPrivate('172.32.0.5'), false);
263			});
264
265			it('should check if an address is from a 169.254.x.x network', function() {
266			assert.equal(ip.isPrivate('169.254.2.3'), true);
267			assert.equal(ip.isPrivate('169.254.221.9'), true);
268			assert.equal(ip.isPrivate('168.254.2.3'), false);
269			});
270
271			it('should check if an address is from a 10.x.x.x network', function() {
272			assert.equal(ip.isPrivate('10.0.2.3'), true);
273			assert.equal(ip.isPrivate('10.1.23.45'), true);
274			assert.equal(ip.isPrivate('12.1.2.3'), false);
275			});
276
277			it('should check if an address is from a private IPv6 network', function() {
278			assert.equal(ip.isPrivate('fd12:3456:789a:1::1'), true);
279			assert.equal(ip.isPrivate('fe80::f2de:f1ff:fe3f:307e'), true);
280			assert.equal(ip.isPrivate('::ffff:10.100.1.42'), true);
281			assert.equal(ip.isPrivate('::FFFF:172.16.200.1'), true);
282			assert.equal(ip.isPrivate('::ffff:192.168.0.1'), true);
283			});
284
285			it('should check if an address is from the internet', function() {
286			assert.equal(ip.isPrivate('165.225.132.33'), false); // joyent.com
287			});
288
289			it('should check if an address is a loopback IPv6 address', function() {
290			assert.equal(ip.isPrivate('::'), true);
291			assert.equal(ip.isPrivate('::1'), true);
292			assert.equal(ip.isPrivate('fe80::1'), true);
293			});
294			});
295
296			describe('loopback() method', function() {
297			describe('undefined', function() {
298			it('should respond with 127.0.0.1', function() {
299			assert.equal(ip.loopback(), '127.0.0.1')
300			});
301			});
302
303			describe('ipv4', function() {
304			it('should respond with 127.0.0.1', function() {
305			assert.equal(ip.loopback('ipv4'), '127.0.0.1')
306			});
307			});
308
309			describe('ipv6', function() {
310			it('should respond with fe80::1', function() {
311			assert.equal(ip.loopback('ipv6'), 'fe80::1')
312			});
313			});
314			});
315
316			describe('isLoopback() method', function() {
317			describe('127.0.0.1', function() {
318			it('should respond with true', function() {
319			assert.ok(ip.isLoopback('127.0.0.1'))
320			});
321			});
322
323			describe('127.8.8.8', function () {
324			it('should respond with true', function () {
325			assert.ok(ip.isLoopback('127.8.8.8'))
326			});
327			});
328
329			describe('8.8.8.8', function () {
330			it('should respond with false', function () {
331			assert.equal(ip.isLoopback('8.8.8.8'), false);
332			});
333			});
334
335			describe('fe80::1', function() {
336			it('should respond with true', function() {
337			assert.ok(ip.isLoopback('fe80::1'))
338			});
339			});
340
341			describe('::1', function() {
342			it('should respond with true', function() {
343			assert.ok(ip.isLoopback('::1'))
344			});
345			});
346
347			describe('::', function() {
348			it('should respond with true', function() {
349			assert.ok(ip.isLoopback('::'))
350			});
351			});
352			});
353
354			describe('address() method', function() {
355			describe('undefined', function() {
356			it('should respond with a private ip', function() {
357			assert.ok(ip.isPrivate(ip.address()));
358			});
359			});
360
361			describe('private', function() {
362			[ undefined, 'ipv4', 'ipv6' ].forEach(function(family) {
363			describe(family, function() {
364			it('should respond with a private ip', function() {
365			assert.ok(ip.isPrivate(ip.address('private', family)));
366			});
367			});
368			});
369			});
370
371			var interfaces = os.networkInterfaces();
372
373			Object.keys(interfaces).forEach(function(nic) {
374			describe(nic, function() {
375			[ undefined, 'ipv4' ].forEach(function(family) {
376			describe(family, function() {
377			it('should respond with an ipv4 address', function() {
378			var addr = ip.address(nic, family);
379			assert.ok(!addr \|\| net.isIPv4(addr));
380			});
381			});
382			});
383
384			describe('ipv6', function() {
385			it('should respond with an ipv6 address', function() {
386			var addr = ip.address(nic, 'ipv6');
387			assert.ok(!addr \|\| net.isIPv6(addr));
388			});
389			})
390			});
391			});
392			});
393
394			describe('toLong() method', function() {
395			it('should respond with a int', function() {
396			assert.equal(ip.toLong('127.0.0.1'), 2130706433);
397			assert.equal(ip.toLong('255.255.255.255'), 4294967295);
398			});
399			});
400
401			describe('fromLong() method', function() {
402			it('should repond with ipv4 address', function() {
403			assert.equal(ip.fromLong(2130706433), '127.0.0.1');
404			assert.equal(ip.fromLong(4294967295), '255.255.255.255');
405			});
406			})
407			});
408

LukasMeine / vigilance

describe(ꞌIP library for node.jsꞌ) A last analyzed 2018-08-02 16:14 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

describe(ꞌIP library for node.jsꞌ) A
last analyzed 2018-08-02 16:14 UTC